﻿using ManagementSystem.Model.EF;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Entity.Infrastructure;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ManagementSystem.Service
{
    /// <summary>
    /// 系统功能实现服务类
    /// </summary>
    public partial class SystemServices : Form
    {
        public SystemServices()
        {
            //初始化
            InitializeComponent();
        }

        private void SystemServices_Load(object sender, EventArgs e)
        {

        }
    }
}

/// <summary>
/// 系统服务类（即实现增、删、改、查功能）
/// </summary>
internal class SystemServices
{
    /// <summary>
    /// 获得数据库中表Student所有数据
    /// </summary>
    /// <returns></returns>
    public List<Student> GetAlls()
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //返回获得学生数据
        return db.Student.ToList();
    }

    /// <summary>
    /// 获得数据库中表Teacher所有数据
    /// </summary>
    /// <returns></returns>
    public List<Teacher> GetAllt()
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //返回获得教师数据
        return db.Teacher.ToList();
    }

    /// <summary>
    /// 获取数据库中表Course所有数据
    /// </summary>
    /// <returns></returns>
    public List<Course> GetAllc()
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //返回获得课程数据
        return db.Course.ToList();
    }

    /// <summary>
    /// 新增学生信息方法
    /// </summary>
    /// <param name="models"></param>
    /// <exception cref="Exception"></exception>
    public void Creates(CreateModels models)
    {
        // 确保传入的 ID 是非空且符合预期长度或格式
        if (string.IsNullOrWhiteSpace(models.ID))
        {
            MessageBox.Show("ID格式有误,请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        // 检查是否已经有相同的 ID 存在于数据库中
        if (db.Student.Any(x => x.ID == models.ID))
        {
            MessageBox.Show("该ID已存在，请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }

        // 创建一个新的 Student 对象实例
        var newItem = new Student()
        {
            ID = models.ID,
            Name = models.Name,
            Class = models.Class,
            Password = models.Password,
            Hometown = models.Hometown,
        };

        //向数据库中“增”
        db.Student.Add(newItem);

        //异常处理
        try
        {
            //更新
            db.SaveChanges();
        }
        catch (DbUpdateException ex)
        {
            // 处理可能发生的数据库更新错误，如唯一约束冲突等
            throw new Exception("Failed to create the address due to a database error.", ex);
        }
    }

    /// <summary>
    /// 新增教师信息
    /// </summary>
    /// <param name="model"></param>
    /// <exception cref="ArgumentException"></exception>
    /// <exception cref="InvalidOperationException"></exception>
    /// <exception cref="Exception"></exception>
    public void Createt(CreateModelt modelt)
    {
        // 确保传入的 ID 是非空且符合预期长度或格式
        if (string.IsNullOrWhiteSpace(modelt.ID))
        {
            MessageBox.Show("ID格式有误,请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        // 检查是否已经有相同的 ID 存在于数据库中
        if (db.Teacher.Any(x => x.ID == modelt.ID))
        {
            MessageBox.Show("该ID已存在，请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }

        // 创建一个新的 Teacher 对象实例。
        var newItem = new Teacher()
        {
            ID = modelt.ID,
            Name = modelt.Name,
            Title = modelt.Title,
            Password = modelt.Password,
        };

        //向数据库中“增”
        db.Teacher.Add(newItem);

        //异常处理
        try
        {
            //更新
            db.SaveChanges();
        }
        catch (DbUpdateException ex)
        {
            // 处理可能发生的数据库更新错误，如唯一约束冲突等
            throw new Exception("Failed to create the address due to a database error.", ex);
        }
    }

    /// <summary>
    /// 新增课程信息
    /// </summary>
    /// <param name="model"></param>
    /// <exception cref="ArgumentException"></exception>
    /// <exception cref="InvalidOperationException"></exception>
    /// <exception cref="Exception"></exception>
    public void Createc(CreateModelc modelc)
    {
        // 确保传入的 ID 是非空且符合预期长度或格式
        if (string.IsNullOrWhiteSpace(modelc.ID))
        {
            MessageBox.Show("ID格式有误,请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        // 检查是否已经有相同的 ID 存在于数据库中
        if (db.Course.Any(x => x.ID == modelc.ID))
        {
            MessageBox.Show("该ID已存在，请检查", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }

        // 创建一个新的 Course 对象实例。
        var newItem = new Course()
        {
            ID = modelc.ID,
            Name = modelc.Name,
            Teacher = modelc.Teacher,
            Credit = modelc.Credit,
        };

        //向数据库中“增”
        db.Course.Add(newItem);

        //异常处理
        try
        {
            //更新
            db.SaveChanges();
        }
        catch (DbUpdateException ex)
        {
            // 处理可能发生的数据库更新错误，如唯一约束冲突等
            throw new Exception("Failed to create the address due to a database error.", ex);
        }
    }

    /// <summary>
    /// 获取要修改的学生信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    public Student GetBysID(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //根据ID获取该学生信息
        return db.Student.Find(ID);
    }

    /// <summary>
    /// 修改学生信息
    /// </summary>
    /// <param name="models"></param>
    public void Edits(EditModels models)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的学生记录
        var item = db.Student.Find(models.ID);

        //查到信息不为空则执行修改操作
        if (item != null)
        {
            item.ID = models.ID;
            item.Name = models.Name;
            item.Class = models.Class;
            item.Password = models.Password;
            item.Hometown = models.Hometown;
        }

        //更新
        db.SaveChanges();
    }

    /// <summary>
    /// 获取要修改的教师信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    public Teacher GetBytID(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //根据ID获取该教师信息
        return db.Teacher.Find(ID);
    }

    /// <summary>
    /// 修改教师信息
    /// </summary>
    /// <param name="modelt"></param>
    public void Editt(EditModelt modelt)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的教师记录
        var item = db.Teacher.Find(modelt.ID);

        //查到信息不为空则执行修改操作
        if (item != null)
        {
            item.ID = modelt.ID;
            item.Name = modelt.Name;
            item.Title = modelt.Title;
            item.Password = modelt.Password;
        }

        //更新
        db.SaveChanges();
    }

    /// <summary>
    /// 获取要修改的课程信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    public Course GetBycID(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //根据ID获取该课程信息
        return db.Course.Find(ID);
    }

    /// <summary>
    /// 修改课程信息
    /// </summary>
    /// <param name="modelc"></param>
    public void Editc(EditModelc modelc)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的课程记录
        var item = db.Course.Find(modelc.ID);

        //查到信息不为空则执行修改操作
        if (item != null)
        {
            item.ID = modelc.ID;
            item.Name = modelc.Name;
            item.Teacher = modelc.Teacher;
            item.Credit = modelc.Credit;
        }

        //更新
        db.SaveChanges();
    }

    /// <summary>
    /// 删除学生信息
    /// </summary>
    /// <param name="ID"></param>
    public void Deletes(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的学生记录
        var item = db.Student.Find(ID);

        //查到信息不为空则执行删除操作
        if (item != null)
        {
            //从数据库中“删”
            db.Student.Remove(item);

            //更新
            db.SaveChanges();
        }
    }

    /// <summary>
    /// 删除教师信息
    /// </summary>
    /// <param name="ID"></param>
    public void Deletet(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的教师记录
        var item = db.Teacher.Find(ID);

        //查到信息不为空则执行删除操作
        if (item != null)
        {
            //从数据库中“删”
            db.Teacher.Remove(item);

            //更新
            db.SaveChanges();
        }
    }

    /// <summary>
    /// 删除课程信息
    /// </summary>
    /// <param name="ID"></param>
    public void Deletec(string ID)
    {
        //创建了一个新的数据库上下文实例db，打开了通往CourseSelectionSystem2024数据库的通道。通过实例db，可以执行增删改查的基本数据库操作
        var db = new CourseSelectionSystem2024Entities();

        //查找具有特定 ID 的课程记录
        var item = db.Course.Find(ID);

        //查到信息不为空则执行删除操作
        if (item != null)
        {
            //从数据库中“删”
            db.Course.Remove(item);

            //更新
            db.SaveChanges();
        }
    }

    /// <summary>
    /// 按学号查询学生信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Student> SelectsID(string ID)
    {
        // 检查传入的学号是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(ID))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者学号不能为空
            throw new ArgumentException("学号不能为空", nameof(ID));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //按学号查询//构建查询：从 Student 表中选择所有其学号（ID）包含传入参数 ID 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query =  db.Student.Where(x => x.ID.Contains(ID));

            //返回查询结果
           return query.ToList();
        }
    }

    /// <summary>
    /// 按姓名查询学生信息
    /// </summary>
    /// <param name="Name"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Student> SelectsName(string Name)
    {
        // 检查传入的姓名是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Name))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者姓名不能为空
            throw new ArgumentException("姓名不能为空", nameof(Name));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Student 表中选择所有其姓名（Name）包含传入参数 Name 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Student.Where(x => x.Name.Contains(Name));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按班级查询学生信息
    /// </summary>
    /// <param name="Class"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Student> SelectsClass(string Class)
    {
        // 检查传入的班级是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Class))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者班级不能为空
            throw new ArgumentException("班级不能为空", nameof(Class));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Student 表中选择所有其班级（Class）包含传入参数 Class 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Student.Where(x => x.Class.Contains(Class));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按籍贯查询学生信息
    /// </summary>
    /// <param name="Hometown"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Student> SelectsHometown(string Hometown)
    {
        // 检查传入的籍贯是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Hometown))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者籍贯不能为空
            throw new ArgumentException("籍贯不能为空", nameof(Hometown));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Student 表中选择所有其籍贯（Hometown）包含传入参数 Hometown 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Student.Where(x => x.Hometown.Contains(Hometown));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按工号查询教师信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Teacher> SelecttID(string ID)
    {
        // 检查传入的工号是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(ID))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者工号不能为空
            throw new ArgumentException("工号不能为空", nameof(ID));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Teacher 表中选择所有其工号（ID）包含传入参数 ID 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Teacher.Where(x => x.ID.Contains(ID));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按姓名查询教师信息
    /// </summary>
    /// <param name="Name"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Teacher> SelecttName(string Name)
    {
        // 检查传入的姓名是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Name))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者姓名不能为空
            throw new ArgumentException("姓名不能为空", nameof(Name));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Teacher 表中选择所有其姓名（Name）包含传入参数 Name 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Teacher.Where(x => x.Name.Contains(Name));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按职称查询教师信息
    /// </summary>
    /// <param name="Title"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Teacher> SelecttTitle(string Title)
    {
        // 检查传入的职称是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Title))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者职称不能为空
            throw new ArgumentException("职称不能为空", nameof(Title));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Teacher 表中选择所有其职称（Title）包含传入参数 Title 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Teacher.Where(x => x.Title.Contains(Title));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按编号查询课程信息
    /// </summary>
    /// <param name="ID"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Course> SelectcID(string ID)
    {
        // 检查传入的课程编号是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(ID))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者课程编号不能为空
            throw new ArgumentException("课程编号不能为空", nameof(ID));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Course 表中选择所有其课程编号（ID）包含传入参数 ID 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Course.Where(x => x.ID.Contains(ID));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按名称查询课程信息
    /// </summary>
    /// <param name="Name"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Course> SelectcName(string Name)
    {
        // 检查传入的课程名称是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Name))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者课程名称不能为空
            throw new ArgumentException("课程名称不能为空", nameof(Name));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Course 表中选择所有其课程名称（Name）包含传入参数 Name 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Course.Where(x => x.Name.Contains(Name));

            //返回查询结果
            return query.ToList();
        }
    }

    /// <summary>
    /// 按授课教师查询课程信息
    /// </summary>
    /// <param name="Teacher"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    public IEnumerable<Course> SelectcTeacher(string Teacher)
    {
        // 检查传入的授课教师是否为空或仅包含空白字符
        if (string.IsNullOrEmpty(Teacher))
        {
            // 如果是，则抛出一个 ArgumentException，提示调用者授课教师不能为空
            throw new ArgumentException("授课教师不能为空", nameof(Teacher));
        }

        // 使用 using 语句创建一个新的数据库上下文实例，using 确保了即使在发生异常的情况下，也会正确地释放资源
        using (var db = new CourseSelectionSystem2024Entities())
        {
            //构建查询：从 Course 表中选择所有其授课教师（Teacher）包含传入参数 Teacher 的记录。 注意：这里使用的是 Contains 方法，意味着进行的是部分匹配，而非精确匹配
            var query = db.Course.Where(x => x.Teacher.Contains(Teacher));

            //返回查询结果
            return query.ToList();
        }
    }
}
